home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1992 June: ROMin Holiday / ADC Developer CD (1992-06) (''ROMin Holiday'')_iso / Developer Connection - 06-1992.iso / Developer Essentials / MPW Interfaces & Libraries / PInterfaces / PasLibIntf.p < prev    next >
Encoding:
Text File  |  1992-01-29  |  4.5 KB  |  221 lines  |  [TEXT/MPS ]
  1.  
  2. {
  3. Created: Monday, January 22, 1990 at 9:18 PM
  4.     PasLibIntf.p
  5.     Pascal Interface to the Macintosh Libraries
  6.  
  7.     Copyright Apple Computer, Inc.    1986-1991
  8.     All rights reserved
  9.     
  10.     
  11.     Interface to the Pascal I/O and Memory Manager Library.
  12.     Built-in procedure and function declarations are marked with
  13.     the (* *) comment characters
  14.     
  15. }
  16.  
  17.  
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.     UNIT PASLIBIntf;
  24.       INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED UsingPASLIBINTF}
  28. {$SETC UsingPASLIBINTF := 1}
  29.  
  30. {$I+}
  31. {$SETC PASLIBINTFIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33. {$IFC UNDEFINED UsingTypes}
  34. {$I $$Shell(PInterfaces)Types.p}
  35. {$ENDC}
  36. {$SETC UsingIncludes := PASLIBINTFIncludes}
  37.  
  38.     TYPE
  39.       PASCALPOINTER = ^INTEGER; { Universal POINTER type }
  40.       PASCALFILE = FILE; { Universal FILE type }
  41. (*
  42.  *      PASCALBLOCK =    { Universal block of chars }
  43.  *            PACKED ARRAY [0..511] OF CHAR;
  44.  *)
  45.  
  46.     CONST
  47.       { <StdIO.h> PLSetVBuf styles }
  48.       _IOFBF = $00; { File buffering }
  49.       _IOLBF = $40; { Line buffering }
  50.       _IONBF = $04; { No buffering }
  51.  
  52. {
  53.  Mac Pascal heap management
  54. }
  55.  
  56.     PROCEDURE PLHeapInit(sizepheap: LONGINT; heapDelta: LONGINT;
  57.                          memerrProc: UNIV PASCALPOINTER; allowNonCont: BOOLEAN;
  58.                          forDispose: BOOLEAN);
  59. {
  60.  The following procedure is obsolete, use PLHeapInit
  61. }
  62.  
  63.     PROCEDURE PLInitHeap(sizepheap: LONGINT; memerrProc: UNIV PASCALPOINTER;
  64.                          allowNonCont: BOOLEAN; allowDispose: BOOLEAN);
  65.  
  66.     PROCEDURE PLSetNonCont(allowNonCont: BOOLEAN);
  67.  
  68.     PROCEDURE PLSetMErrProc(memerrProc: UNIV PASCALPOINTER);
  69.  
  70.     PROCEDURE PLSetHeapType(forDispose: BOOLEAN);
  71.  
  72.     PROCEDURE PLSetHeapCheck(DoIt: BOOLEAN);
  73.  
  74. {
  75.  File I/O
  76. }
  77.  
  78. (*
  79.  *      PROCEDURE
  80.  *        RESET(VAR fvar:  UNIV PASCALFILE; OPT fname: STRING);
  81.  *        BUILTIN;
  82.  *
  83.  *      PROCEDURE
  84.  *        REWRITE(VAR fvar: UNIV PASCALFILE; OPT fname: STRING);
  85.  *        BUILTIN;
  86.  *
  87.  *      PROCEDURE
  88.  *        OPEN(VAR fvar:    UNIV PASCALFILE; fname: STRING);
  89.  *        BUILTIN;
  90.  *)
  91.  
  92.     PROCEDURE PLSetVBuf(VAR fvar: TEXT; buffer: UNIV PASCALPOINTER;
  93.                         style: INTEGER; bufsize: INTEGER);
  94. (*
  95.  *      FUNCTION
  96.  *        BLOCKREAD(
  97.  *          VAR fvar: FILE;
  98.  *          VAR buffer: UNIV PASCALBLOCK;
  99.  *          nBlocks: INTEGER;
  100.  *          OPT stBlock:INTEGER
  101.  *        ):
  102.  *        INTEGER;
  103.  *        BUILTIN;
  104.  *
  105.  *      FUNCTION
  106.  *        BLOCKWRITE(
  107.  *          VAR fvar: FILE;
  108.  *          VAR buffer: UNIV PASCALBLOCK;
  109.  *          nBlocks: INTEGER;
  110.  *          OPT stBlock:INTEGER
  111.  *        ):
  112.  *        INTEGER;
  113.  *        BUILTIN;
  114.  *
  115.  *      FUNCTION
  116.  *        BYTEREAD(
  117.  *          VAR fvar: FILE;
  118.  *          VAR buffer: UNIV PASCALBLOCK;
  119.  *          nBytes:  LONGINT;
  120.  *          OPT stByte: LONGINT
  121.  *        ):
  122.  *        LONGINT;
  123.  *        BUILTIN;
  124.  *
  125.  *      FUNCTION
  126.  *        BYTEWRITE(
  127.  *          VAR fvar: FILE;
  128.  *          VAR buffer: UNIV PASCALBLOCK;
  129.  *          nBytes:  LONGINT;
  130.  *          OPT stByte: LONGINT
  131.  *        ):
  132.  *        LONGINT;
  133.  *        BUILTIN;
  134.  *
  135.  *      FUNCTION
  136.  *        EOF(OPT VAR fvar: UNIV PASCALFILE):
  137.  *        BOOLEAN;
  138.  *        BUILTIN;
  139.  *
  140.  *      FUNCTION
  141.  *        EOLN(OPT VAR fvar: TEXT):
  142.  *        BOOLEAN;
  143.  *        BUILTIN;
  144.  *
  145.  *      PROCEDURE
  146.  *        READ(VAR fvar: TEXT; OPT EXPR_LIST);
  147.  *        BUILTIN;
  148.  *
  149.  *      PROCEDURE
  150.  *        READLN(OPT VAR fvar: TEXT; OPT EXPR_LIST);
  151.  *        BUILTIN;
  152.  *
  153.  *      PROCEDURE
  154.  *        WRITE(VAR fvar: TEXT; OPT EXPR_LIST);
  155.  *        BUILTIN;
  156.  *
  157.  *      PROCEDURE
  158.  *        WRITELN(OPT VAR fvar: TEXT; OPT EXPR_LIST);
  159.  *        BUILTIN;
  160.  *
  161.  *      PROCEDURE
  162.  *        GET(VAR fvar: UNIV PASCALFILE);
  163.  *        BUILTIN;
  164.  *
  165.  *      PROCEDURE
  166.  *        PUT(VAR fvar: UNIV PASCALFILE);
  167.  *        BUILTIN;
  168.  *
  169.  *      PROCEDURE
  170.  *        SEEK(VAR fvar: UNIV PASCALFILE; recno: LONGINT);
  171.  *        BUILTIN;
  172.  *)
  173.  
  174.     FUNCTION PLFilePos(VAR fvar: UNIV PASCALFILE): LONGINT;
  175.  
  176.     PROCEDURE PLFlush(VAR fvar: TEXT);
  177.  
  178.     PROCEDURE PLCrunch(VAR fvar: UNIV PASCALFILE);
  179. {
  180.  Directory operations.
  181. }
  182.  
  183.     PROCEDURE PLPurge(fname: STRING);
  184.  
  185.     PROCEDURE PLRename(oldFname, newFname: STRING);
  186.  
  187. {
  188.  C string functions for Pascal strings
  189. }
  190.      FUNCTION PLStrCmp(string1, string2: STR255): INTEGER;
  191.  
  192.     FUNCTION PLStrnCmp(string1, string2: STR255; n: INTEGER): INTEGER;
  193.  
  194.     FUNCTION PLStrCpy(VAR string1: STR255; string2: STR255): STRINGPTR;
  195.  
  196.     FUNCTION PLStrnCpy(VAR string1: STR255; string2: STR255; n: INTEGER): STRINGPTR;
  197.  
  198.     FUNCTION PLStrCat(VAR string1: STR255; string2: STR255): STRINGPTR;
  199.  
  200.     FUNCTION PLStrnCat(VAR string1: STR255; string2: STR255; n: INTEGER): STRINGPTR;
  201.  
  202.     FUNCTION PLStrChr(string1: STR255; c: CHAR): PTR;
  203.  
  204.     FUNCTION PLStrrChr(string1: STR255; c: CHAR): PTR;
  205.  
  206.     FUNCTION PLStrPBrk(string1, string2: STR255): PTR;
  207.  
  208.     FUNCTION PLStrSpn(string1, string2: STR255): INTEGER;
  209.  
  210.     FUNCTION PLStrStr(string1, string2: STR255): PTR;
  211.  
  212.     FUNCTION PLStrLen(string1: STR255): INTEGER;
  213.     
  214.     FUNCTION PLPos(STRING1: STR255; STRING2: STR255): INTEGER;
  215.  
  216. {$ENDC}    { UsingPASLIBINTF }
  217.  
  218. {$IFC NOT UsingIncludes}
  219.     END.
  220. {$ENDC}
  221.